home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / RTLWIN32.PAK / VDMDBG.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  14KB  |  538 lines
  1. /*++ BUILD Version: 0001    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1985-1996, Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     vdmdbg.h
  8.  
  9. Abstract:
  10.  
  11.     Prodecure declarations, constant definitions, type definition and macros
  12.     for the VDMDBG.DLL VDM Debugger interface.
  13.  
  14. --*/
  15.  
  16. /* $Copyright: 1997$ */
  17.  
  18. #ifndef _VDMDBG_
  19. #define _VDMDBG_
  20. #pragma option -b
  21.  
  22. #ifdef __cplusplus
  23. extern "C" {
  24. #endif
  25.  
  26. #pragma option -b.
  27. #include <pshpack4.h>
  28. #pragma option -b
  29.  
  30. #define STATUS_VDM_EVENT    STATUS_SEGMENT_NOTIFICATION
  31.  
  32. #ifndef DBG_SEGLOAD
  33. #define DBG_SEGLOAD     0
  34. #define DBG_SEGMOVE     1
  35. #define DBG_SEGFREE     2
  36. #define DBG_MODLOAD     3
  37. #define DBG_MODFREE     4
  38. #define DBG_SINGLESTEP  5
  39. #define DBG_BREAK       6
  40. #define DBG_GPFAULT     7
  41. #define DBG_DIVOVERFLOW 8
  42. #define DBG_INSTRFAULT  9
  43. #define DBG_TASKSTART   10
  44. #define DBG_TASKSTOP    11
  45. #define DBG_DLLSTART    12
  46. #define DBG_DLLSTOP     13
  47. #define DBG_ATTACH      14
  48. #endif
  49.  
  50. //
  51. // The following flags control the contents of the CONTEXT structure.
  52. //
  53.  
  54. #define VDMCONTEXT_i386    0x00010000    // this assumes that i386 and
  55. #define VDMCONTEXT_i486    0x00010000    // i486 have identical context records
  56.  
  57. #define VDMCONTEXT_CONTROL         (VDMCONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP
  58. #define VDMCONTEXT_INTEGER         (VDMCONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI
  59. #define VDMCONTEXT_SEGMENTS        (VDMCONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS
  60. #define VDMCONTEXT_FLOATING_POINT  (VDMCONTEXT_i386 | 0x00000008L) // 387 state
  61. #define VDMCONTEXT_DEBUG_REGISTERS (VDMCONTEXT_i386 | 0x00000010L) // DB 0-3,6,7
  62.  
  63. #define VDMCONTEXT_FULL (VDMCONTEXT_CONTROL | VDMCONTEXT_INTEGER |\
  64.                       VDMCONTEXT_SEGMENTS)
  65.  
  66.  
  67. #ifdef _X86_
  68.  
  69. // On x86 machines, just copy the definition of the CONTEXT and LDT_ENTRY
  70. // structures.
  71. typedef struct _CONTEXT VDMCONTEXT;
  72. typedef struct _LDT_ENTRY VDMLDT_ENTRY;
  73.  
  74. #else // _X86_
  75.  
  76. //
  77. //  Define the size of the 80387 save area, which is in the context frame.
  78. //
  79.  
  80. #define SIZE_OF_80387_REGISTERS      80
  81.  
  82. typedef struct _FLOATING_SAVE_AREA {
  83.     ULONG   ControlWord;
  84.     ULONG   StatusWord;
  85.     ULONG   TagWord;
  86.     ULONG   ErrorOffset;
  87.     ULONG   ErrorSelector;
  88.     ULONG   DataOffset;
  89.     ULONG   DataSelector;
  90.     UCHAR   RegisterArea[SIZE_OF_80387_REGISTERS];
  91.     ULONG   Cr0NpxState;
  92. } FLOATING_SAVE_AREA;
  93.  
  94. //
  95. // Simulated context structure for the 16-bit environment
  96. //
  97.  
  98. typedef struct _VDMCONTEXT {
  99.  
  100.     //
  101.     // The flags values within this flag control the contents of
  102.     // a CONTEXT record.
  103.     //
  104.     // If the context record is used as an input parameter, then
  105.     // for each portion of the context record controlled by a flag
  106.     // whose value is set, it is assumed that that portion of the
  107.     // context record contains valid context. If the context record
  108.     // is being used to modify a threads context, then only that
  109.     // portion of the threads context will be modified.
  110.     //
  111.     // If the context record is used as an IN OUT parameter to capture
  112.     // the context of a thread, then only those portions of the thread's
  113.     // context corresponding to set flags will be returned.
  114.     //
  115.     // The context record is never used as an OUT only parameter.
  116.     //
  117.     // CONTEXT_FULL on some systems (MIPS namely) does not contain the
  118.     // CONTEXT_SEGMENTS definition.  VDMDBG assumes that CONTEXT_INTEGER also
  119.     // includes CONTEXT_SEGMENTS to account for this.
  120.     //
  121.  
  122.     ULONG ContextFlags;
  123.  
  124.     //
  125.     // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
  126.     // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
  127.     // included in CONTEXT_FULL.
  128.     //
  129.  
  130.     ULONG   Dr0;
  131.     ULONG   Dr1;
  132.     ULONG   Dr2;
  133.     ULONG   Dr3;
  134.     ULONG   Dr6;
  135.     ULONG   Dr7;
  136.  
  137.     //
  138.     // This section is specified/returned if the
  139.     // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
  140.     //
  141.  
  142.     FLOATING_SAVE_AREA FloatSave;
  143.  
  144.     //
  145.     // This section is specified/returned if the
  146.     // ContextFlags word contians the flag CONTEXT_SEGMENTS.
  147.     //
  148.  
  149.     ULONG   SegGs;
  150.     ULONG   SegFs;
  151.     ULONG   SegEs;
  152.     ULONG   SegDs;
  153.  
  154.     //
  155.     // This section is specified/returned if the
  156.     // ContextFlags word contians the flag CONTEXT_INTEGER.
  157.     //
  158.  
  159.     ULONG   Edi;
  160.     ULONG   Esi;
  161.     ULONG   Ebx;
  162.     ULONG   Edx;
  163.     ULONG   Ecx;
  164.     ULONG   Eax;
  165.  
  166.     //
  167.     // This section is specified/returned if the
  168.     // ContextFlags word contians the flag CONTEXT_CONTROL.
  169.     //
  170.  
  171.     ULONG   Ebp;
  172.     ULONG   Eip;
  173.     ULONG   SegCs;              // MUST BE SANITIZED
  174.     ULONG   EFlags;             // MUST BE SANITIZED
  175.     ULONG   Esp;
  176.     ULONG   SegSs;
  177.  
  178. } VDMCONTEXT;
  179.  
  180. //
  181. //  LDT descriptor entry
  182. //
  183.  
  184. typedef struct _VDMLDT_ENTRY {
  185.     USHORT  LimitLow;
  186.     USHORT  BaseLow;
  187.     union {
  188.         struct {
  189.             UCHAR   BaseMid;
  190.             UCHAR   Flags1;     // Declare as bytes to avoid alignment
  191.             UCHAR   Flags2;     // Problems.
  192.             UCHAR   BaseHi;
  193.         } Bytes;
  194.         struct {
  195.             ULONG   BaseMid : 8;
  196.             ULONG   Type : 5;
  197.             ULONG   Dpl : 2;
  198.             ULONG   Pres : 1;
  199.             ULONG   LimitHi : 4;
  200.             ULONG   Sys : 1;
  201.             ULONG   Reserved_0 : 1;
  202.             ULONG   Default_Big : 1;
  203.             ULONG   Granularity : 1;
  204.             ULONG   BaseHi : 8;
  205.         } Bits;
  206.     } HighWord;
  207. } VDMLDT_ENTRY;
  208.  
  209.  
  210. #endif // _X86_
  211.  
  212. typedef VDMCONTEXT *LPVDMCONTEXT;
  213. typedef VDMLDT_ENTRY *LPVDMLDT_ENTRY;
  214.  
  215. #define VDMCONTEXT_TO_PROGRAM_COUNTER(Context) (PVOID)((Context)->Eip)
  216.  
  217. #define VDMCONTEXT_LENGTH  (sizeof(VDMCONTEXT))
  218. #define VDMCONTEXT_ALIGN   (sizeof(ULONG))
  219. #define VDMCONTEXT_ROUND   (VDMCONTEXT_ALIGN - 1)
  220.  
  221. #define V86FLAGS_CARRY      0x00001
  222. #define V86FLAGS_PARITY     0x00004
  223. #define V86FLAGS_AUXCARRY   0x00010
  224. #define V86FLAGS_ZERO       0x00040
  225. #define V86FLAGS_SIGN       0x00080
  226. #define V86FLAGS_TRACE      0x00100
  227. #define V86FLAGS_INTERRUPT  0x00200
  228. #define V86FLAGS_DIRECTION  0x00400
  229. #define V86FLAGS_OVERFLOW   0x00800
  230. #define V86FLAGS_IOPL       0x03000
  231. #define V86FLAGS_IOPL_BITS  0x12
  232. #define V86FLAGS_RESUME     0x10000
  233. #define V86FLAGS_V86        0x20000     // Used to detect RealMode v. ProtMode
  234. #define V86FLAGS_ALIGNMENT  0x40000
  235.  
  236. #define MAX_MODULE_NAME  8 + 1
  237. #define MAX_PATH16      255
  238.  
  239. typedef struct _SEGMENT_NOTE {
  240.     WORD    Selector1;                      // Selector of operation
  241.     WORD    Selector2;                      // Dest. Sel. for moving segments
  242.     WORD    Segment;                        // Segment within Module
  243.     CHAR    Module[MAX_MODULE_NAME+1];      // Module name
  244.     CHAR    FileName[MAX_PATH16+1];         // PathName to executable image
  245.     WORD    Type;                           // Code / Data, etc.
  246.     DWORD   Length;                         // Length of image
  247. } SEGMENT_NOTE;
  248.  
  249. typedef struct _IMAGE_NOTE {
  250.     CHAR    Module[MAX_MODULE_NAME+1];      // Module
  251.     CHAR    FileName[MAX_PATH16+1];         // Path to executable image
  252.     WORD    hModule;                        // 16-bit hModule
  253.     WORD    hTask;                          // 16-bit hTask
  254. } IMAGE_NOTE;
  255.  
  256. typedef struct {
  257.     DWORD   dwSize;
  258.     char    szModule[MAX_MODULE_NAME+1];
  259.     HANDLE  hModule;
  260.     WORD    wcUsage;
  261.     char    szExePath[MAX_PATH16+1];
  262.     WORD    wNext;
  263. } MODULEENTRY, *LPMODULEENTRY;
  264.  
  265. /* GlobalFirst()/GlobalNext() flags */
  266. #define GLOBAL_ALL      0
  267. #define GLOBAL_LRU      1
  268. #define GLOBAL_FREE     2
  269.  
  270. /* GLOBALENTRY.wType entries */
  271. #define GT_UNKNOWN      0
  272. #define GT_DGROUP       1
  273. #define GT_DATA         2
  274. #define GT_CODE         3
  275. #define GT_TASK         4
  276. #define GT_RESOURCE     5
  277. #define GT_MODULE       6
  278. #define GT_FREE         7
  279. #define GT_INTERNAL     8
  280. #define GT_SENTINEL     9
  281. #define GT_BURGERMASTER 10
  282.  
  283. /* If GLOBALENTRY.wType==GT_RESOURCE, the following is GLOBALENTRY.wData: */
  284. #define GD_USERDEFINED      0
  285. #define GD_CURSORCOMPONENT  1
  286. #define GD_BITMAP           2
  287. #define GD_ICONCOMPONENT    3
  288. #define GD_MENU             4
  289. #define GD_DIALOG           5
  290. #define GD_STRING           6
  291. #define GD_FONTDIR          7
  292. #define GD_FONT             8
  293. #define GD_ACCELERATORS     9
  294. #define GD_RCDATA           10
  295. #define GD_ERRTABLE         11
  296. #define GD_CURSOR           12
  297. #define GD_ICON             14
  298. #define GD_NAMETABLE        15
  299. #define GD_MAX_RESOURCE     15
  300.  
  301. typedef struct {
  302.     DWORD   dwSize;
  303.     DWORD   dwAddress;
  304.     DWORD   dwBlockSize;
  305.     HANDLE  hBlock;
  306.     WORD    wcLock;
  307.     WORD    wcPageLock;
  308.     WORD    wFlags;
  309.     BOOL    wHeapPresent;
  310.     HANDLE  hOwner;
  311.     WORD    wType;
  312.     WORD    wData;
  313.     DWORD   dwNext;
  314.     DWORD   dwNextAlt;
  315. } GLOBALENTRY, *LPGLOBALENTRY;
  316.  
  317. typedef DWORD (CALLBACK* DEBUGEVENTPROC)( LPDEBUG_EVENT, LPVOID );
  318.  
  319. // Macros to access VDM_EVENT parameters
  320. #define W1(x) ((USHORT)(x.ExceptionInformation[0]))
  321. #define W2(x) ((USHORT)(x.ExceptionInformation[0] >> 16))
  322. #define W3(x) ((USHORT)(x.ExceptionInformation[1]))
  323. #define W4(x) ((USHORT)(x.ExceptionInformation[1] >> 16))
  324. #define DW3(x) (x.ExceptionInformation[2])
  325. #define DW4(x) (x.ExceptionInformation[3])
  326.  
  327. #pragma option -b.
  328. #include <poppack.h>
  329. #pragma option -b
  330.  
  331. BOOL
  332. WINAPI
  333. VDMProcessException(
  334.     LPDEBUG_EVENT   lpDebugEvent
  335.     );
  336.  
  337. BOOL
  338. WINAPI
  339. VDMGetThreadSelectorEntry(
  340.     HANDLE          hProcess,
  341.     HANDLE          hThread,
  342.     WORD            wSelector,
  343.     LPVDMLDT_ENTRY  lpSelectorEntry
  344.     );
  345.  
  346. ULONG
  347. WINAPI
  348. VDMGetPointer(
  349.     HANDLE          hProcess,
  350.     HANDLE          hThread,
  351.     WORD            wSelector,
  352.     DWORD           dwOffset,
  353.     BOOL            fProtMode
  354.     );
  355.  
  356. BOOL
  357. WINAPI
  358. VDMGetThreadContext(
  359.     LPDEBUG_EVENT   lpDebugEvent,
  360.     LPVDMCONTEXT    lpVDMContext
  361. );
  362.  
  363. BOOL
  364. WINAPI
  365. VDMSetThreadContext(
  366.     LPDEBUG_EVENT   lpDebugEvent,
  367.     LPVDMCONTEXT    lpVDMContext
  368. );
  369.  
  370. BOOL
  371. WINAPI
  372. VDMGetSelectorModule(
  373.     HANDLE          hProcess,
  374.     HANDLE          hThread,
  375.     WORD            wSelector,
  376.     PUINT           lpSegmentNumber,
  377.     LPSTR           lpModuleName,
  378.     UINT            nNameSize,
  379.     LPSTR           lpModulePath,
  380.     UINT            nPathSize
  381. );
  382.  
  383. BOOL
  384. WINAPI
  385. VDMGetModuleSelector(
  386.     HANDLE          hProcess,
  387.     HANDLE          hThread,
  388.     UINT            wSegmentNumber,
  389.     LPSTR           lpModuleName,
  390.     LPWORD          lpSelector
  391. );
  392.  
  393. BOOL
  394. WINAPI
  395. VDMModuleFirst(
  396.     HANDLE          hProcess,
  397.     HANDLE          hThread,
  398.     LPMODULEENTRY   lpModuleEntry,
  399.     DEBUGEVENTPROC  lpEventProc,
  400.     LPVOID          lpData
  401. );
  402.  
  403. BOOL
  404. WINAPI
  405. VDMModuleNext(
  406.     HANDLE          hProcess,
  407.     HANDLE          hThread,
  408.     LPMODULEENTRY   lpModuleEntry,
  409.     DEBUGEVENTPROC  lpEventProc,
  410.     LPVOID          lpData
  411. );
  412.  
  413. BOOL
  414. WINAPI
  415. VDMGlobalFirst(
  416.     HANDLE          hProcess,
  417.     HANDLE          hThread,
  418.     LPGLOBALENTRY   lpGlobalEntry,
  419.     WORD            wFlags,
  420.     DEBUGEVENTPROC  lpEventProc,
  421.     LPVOID          lpData
  422. );
  423.  
  424. BOOL
  425. WINAPI
  426. VDMGlobalNext(
  427.     HANDLE          hProcess,
  428.     HANDLE          hThread,
  429.     LPGLOBALENTRY   lpGlobalEntry,
  430.     WORD            wFlags,
  431.     DEBUGEVENTPROC  lpEventProc,
  432.     LPVOID          lpData
  433. );
  434.  
  435. typedef BOOL (WINAPI *PROCESSENUMPROC)( DWORD dwProcessId, DWORD dwAttributes, LPARAM lpUserDefined );
  436. typedef BOOL (WINAPI *TASKENUMPROC)( DWORD dwThreadId, WORD hMod16, WORD hTask16, LPARAM lpUserDefined );
  437. typedef BOOL (WINAPI *TASKENUMPROCEX)( DWORD dwThreadId, WORD hMod16, WORD hTask16,
  438.                                        PSZ pszModName, PSZ pszFileName, LPARAM lpUserDefined );
  439.  
  440. #define WOW_SYSTEM  (DWORD)0x0001
  441.  
  442. INT
  443. WINAPI
  444. VDMEnumProcessWOW(
  445.     PROCESSENUMPROC fp,
  446.     LPARAM          lparam
  447. );
  448.  
  449. INT
  450. WINAPI
  451. VDMEnumTaskWOW(
  452.     DWORD           dwProcessId,
  453.     TASKENUMPROC    fp,
  454.     LPARAM          lparam
  455. );
  456.  
  457. //
  458. // VDMEnumTaskWOWEx is the same as VDMEnumTaskWOW except
  459. // the callback procedure gets two more parameters,
  460. // the module name of the EXE and the full path to the
  461. // EXE.
  462. //
  463.  
  464. INT
  465. WINAPI
  466. VDMEnumTaskWOWEx(
  467.     DWORD           dwProcessId,
  468.     TASKENUMPROCEX  fp,
  469.     LPARAM          lparam
  470. );
  471.  
  472. //
  473. // VDMTerminateTaskWOW rudely terminates a 16-bit WOW task
  474. // similar to the way TerminateProcess kills a Win32
  475. // process.
  476. //
  477.  
  478. BOOL
  479. WINAPI
  480. VDMTerminateTaskWOW(
  481.     DWORD           dwProcessId,
  482.     WORD            htask
  483. );
  484.  
  485. //
  486. // VDMStartTaskInWOW launches a Win16 task in a pre-existing
  487. // WOW VDM.  Note that the caller is responsible for ensuring
  488. // the program is a 16-bit Windows program.  If it is a DOS
  489. // or Win32 program, it will still be launched from within
  490. // the target WOW VDM.
  491. //
  492. // The supplied command line and show command are passed
  493. // unchanged to the 16-bit WinExec API in the target WOW VDM.
  494. //
  495. // Note this routine is ANSI-only.
  496. //
  497.  
  498. BOOL
  499. VDMStartTaskInWOW(
  500.     DWORD           dwProcessId,
  501.     LPSTR           lpCommandLine,
  502.     WORD            wShow
  503. );
  504.  
  505. //
  506. // VDMKillWOW is not implemented.
  507. //
  508.  
  509. BOOL
  510. WINAPI
  511. VDMKillWOW(
  512.     VOID
  513. );
  514.  
  515. //
  516. // VDMDetectWOW is not implemented.
  517. //
  518.  
  519. BOOL
  520. WINAPI
  521. VDMDetectWOW(
  522.     VOID
  523. );
  524.  
  525. BOOL
  526. WINAPI
  527. VDMBreakThread(
  528.     HANDLE          hProcess,
  529.     HANDLE          hThread
  530. );
  531.  
  532. #ifdef __cplusplus
  533. }
  534. #endif
  535.  
  536. #pragma option -b.
  537. #endif // _VDMDBG_
  538.